package com.zking.ssm.controller;

import com.zking.ssm.model.SysMenu;
import com.zking.ssm.model.SysRoler;
import com.zking.ssm.model.SysUser;
import com.zking.ssm.service.ISysMenuService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.*;
import java.util.stream.Collectors;

@RestController
@RequestMapping("/Menu")
public class MenuController {




    @Autowired
    private ISysMenuService iSysMenuService;


    @RequestMapping("/add")
    public Map<String,Object> add(SysMenu sysMenu){
        int n = iSysMenuService.insert(sysMenu);
        Map<String,Object> map = new HashMap<>();
        if(n > 0){
            map.put("code",0);
            map.put("message","增加菜单成功！");
        }else{
            map.put("code",-1);
            map.put("message","增加菜单失败！");
        }
        return map;
    }

    @RequestMapping("/del")
    public Map<String,Object> del(SysMenu sysMenu){
        int n = iSysMenuService.deleteByPrimaryKey(sysMenu.getMenuId());
        Map<String,Object> map = new HashMap<>();
        if(n > 0){
            map.put("code",0);
            map.put("message","删除菜单成功！");
        }else{
            map.put("code",-1);
            map.put("message","删除菜单失败！");
        }
        return map;
    }


    @RequestMapping("/update")
    public Map<String,Object> update(SysMenu sysMenu){
        int n = iSysMenuService.updateByPrimaryKeySelective(sysMenu);
        Map<String,Object> map = new HashMap<>();
        if(n > 0){
            map.put("code",0);
            map.put("message","修改菜单成功！");
        }else{
            map.put("code",-1);
            map.put("message","修改菜单失败！");
        }
        return map;
    }

    @RequestMapping("/get")
    public Map<String,Object> get(SysRoler sysRoler){
        SysMenu menu = iSysMenuService.selectByPrimaryKey(sysRoler.getRoleId());
        Map<String,Object> map = new HashMap<>();
        if(menu != null){
            map.put("code",0);
            map.put("result",menu);
            map.put("message","查询菜单成功！");
        }else{
            map.put("code",-1);
            map.put("message","查询菜单失败！");
        }
        return map;
    }

    @RequestMapping("/userMenuList")
    public Map<String,Object> userMenuList(SysMenu sysMenu){
        System.out.println("我来查询菜单了"+sysMenu);
        List<SysMenu> menuList = iSysMenuService.userMenuList(sysMenu);
//        List<SysMenu> menus1 = iSysMenuService.list(sysMenu);
        List<SysMenu> l = new ArrayList<>();
        for(SysMenu s : menuList){
            System.out.println(s);
           if(0 == s.getParentId()){
               for(SysMenu s1 : menuList){
                   if(s1.getParentId().equals(s.getMenuId())){
                       s.getSysMenuList().add(s1);
                       l.add(s);
                   }
               }
           }
//            List<SysMenu> menus = iSysMenuService.menuList(s);
//            s.setSysMenuList(menus);
        }

        for (SysMenu sw : l){
            System.out.println("我是被分配的菜单"+sw);
        }

        //        方法一:使用java8新特性stream进行List去重
        List<SysMenu> newList = l.stream().distinct().collect(Collectors.toList());


        Map<String,Object> map = new HashMap<>();
        if(newList.size() > 0){
            map.put("code",0);
            map.put("result",newList);
            map.put("message","查询用户菜单成功！");
        }else{
            map.put("code",-1);
            map.put("message","修改用户菜单失败！");
        }
        return map;
    }

    @RequestMapping("/Test")
    public Map<String,Object> Test(SysMenu sysMenu){
        List<SysMenu> list = iSysMenuService.list(sysMenu);

        List<SysMenu> list1 = new ArrayList<>();
//        Map<String,Object> MenuMap = new HashMap<>();
        for(SysMenu s : list){
            if(s.getParentId() == 0){
                System.out.println("一级菜单是"+s);
                for(SysMenu s1 : list){
                    System.out.println("我来了==============");
                    if(s1.getParentId().equals(s.getMenuId())){
                        System.out.println("我来了");
                        s.getSysMenuList().add(s1);
                        list1.add(s);
                        System.out.println("完毕"+list1.size());
                    }
                }
            }else{
                System.out.println("子菜单是"+s);
            }
        }

        System.out.println(list1.size());

        for(SysMenu s1: list1){
            System.out.println("新集合"+s1);
        }




        Map<String,Object> map = new HashMap<>();
        if(list.size() > 0){
            map.put("code",0);
            map.put("result",list1);
            map.put("message","查询角色菜单成功！");
        }else{
            map.put("code",-1);
            map.put("message","查询角色菜单失败！");
        }
        return map;
    }


    @RequestMapping("/roleMenu")
    public Map<String,Object> roleMenu(SysMenu sysMenu){
        System.out.println("前端传过来的数据"+sysMenu);
        List<SysMenu> list = iSysMenuService.roleMenu(sysMenu);
        List<SysMenu> l = new ArrayList<>();
        List<SysMenu> l2 = new ArrayList<>();//用来和菜单集合作对比，删除空的父菜单记录
        for(SysMenu s : list){//遍历该角色拥有的所有菜单
            if(0 == s.getParentId()){//如果该菜单是父菜单那么将该角色拥有的所有菜单重新遍历一次
                for(SysMenu s1 : list){
                    if(s1.getParentId().equals(s.getMenuId())){//如果该菜单的父菜单id == 第一次遍历的父菜单id
                        s.getSysMenuList().add(s1);//那么就将该菜单加到父菜单的子菜单集合中
                        l.add(s);//用一个新的集合装起来，将新集合返回到客户端
//                        System.out.println("我是有子菜单的父菜单"+s);
                    }else{//如果父菜单是空的，即没有子菜单那么就将该父菜单记录删除
//                        iSysMenuService.removeMenuToRole(sysMenu);
                    }
                }
                l2.add(s);
//                System.out.println("父菜单"+s);
            }
        }
        Map<String,Object> map = new HashMap<>();

//        方法一:使用java8新特性stream进行List去重
        List<SysMenu> newList = l.stream().distinct().collect(Collectors.toList());


    for (SysMenu sysMenu1 : l2) {
        for (SysMenu sysMenu2 : l) {
            if(sysMenu1.getName().equals(sysMenu2.getName())){
                System.out.println("相同的"+sysMenu1);
            }
            if(sysMenu1.getSysMenuList().size() == 0){
                sysMenu.setMenuId(sysMenu1.getMenuId());
                int i = iSysMenuService.removeMenuToRole(sysMenu);
                if(i > 0){
                    System.out.println("删除"+sysMenu1+"菜单成功");
                }
                System.out.println("我是数组对于空的"+sysMenu1);
            }
        }
//        System.out.println("我是所有的父菜单"+sysMenu1);
    }

        for (SysMenu sysMenu1 : l) {
            System.out.println("我是有子菜单的父菜单"+sysMenu1);
        }



        if(newList.size() > 0){
            map.put("code",0);
            map.put("result",newList);
            map.put("message","查询角色菜单成功！");
        }else{
            map.put("code",-1);
            map.put("message","查询角色菜单失败！");
        }
        return map;
    }


    @RequestMapping("/Test6")
    public Map<String,Object> Test6(SysMenu sysMenu){
        Map<String,Object> map = new HashMap<String,Object>();

        List<SysMenu> listAll = iSysMenuService.listAll(sysMenu);

//        for(SysMenu s : listAll){
//            List<SysMenu> menus = iSysMenuService.menuList(s);
//            s.setSysMenuList(menus);
//        }



        Map<String, Object> map1 = this.roleMenu(sysMenu);
        Object result = map1.get("result");
        List<SysMenu> roleHasList = (List<SysMenu>) result;

        for(SysMenu s : listAll){
            for(SysMenu s1 : roleHasList){
                for(SysMenu s2 : s1.getSysMenuList()){
                    if(s.getName().equals(s2.getName())){
                        listAll.remove(s);
                        System.out.println("删除了"+s);
                    }
                }
            }
        }

        for (SysMenu s : listAll){
    System.out.println("最最最新菜单"+s);
}

        for (SysMenu s : roleHasList){
            System.out.println("我是角色已经拥有的所有菜单=========================="+s);
        }

        return map;
    }


    @RequestMapping("/noRoleMenu")
    public Map<String,Object> noRoleMenu(SysMenu sysMenu){

//        List<SysMenu> listAll = iSysMenuService.listAll(sysMenu);



        List<SysMenu> list = iSysMenuService.noRoleMenu(sysMenu);
        for(SysMenu s : list){
            List<SysMenu> menus = iSysMenuService.menuList(s);
            s.setSysMenuList(menus);
        }

        for (SysMenu s : list){
            System.out.println("我是角色未拥有的所有菜单"+s);
        }

//新加的

//        for(SysMenu s : listAll){
//            List<SysMenu> menus = iSysMenuService.menuList(s);
//            s.setSysMenuList(menus);
//        }
//
//
//
//        Map<String, Object> map1 = this.roleMenu(sysMenu);
//        Object result = map1.get("result");
//        List<SysMenu> roleHasList = (List<SysMenu>) result;
//
//        for (SysMenu s : roleHasList){
//            System.out.println("我是角色已经拥有的所有菜单=========================="+s);
//        }

//        List<SysMenu> noList = new ArrayList<>();

//        for (SysMenu s : listAll){
//            for (SysMenu s1 : roleHasList){
//                if(s.getName().equals(s1.getName())){
//                    System.out.println("已拥有的菜单===============+++++++++++++"+s);
//                    for(SysMenu s2 : s.getSysMenuList()){
//                        for(SysMenu s3 : s1.getSysMenuList()){
//                            if(s2.getName().equals(s3.getName())){
//                                s.getSysMenuList().remove(s2);
//                                System.out.println("删除了"+s2);
//                                noList.add(s);
//                            }
//                        }
//                    }
//                }else{
//                    noList.add(s);
//                }
//            }
//            System.out.println("所有的角色"+s);
//        }


//for (SysMenu s : noList){
//    System.out.println("最最最新菜单"+s);
//}


        Map<String,Object> map = new HashMap<>();
        if(list.size() > 0){
            map.put("code",0);
            map.put("result",list);
            map.put("message","查询角色菜单成功！");
        }else{
            map.put("code",-1);
            map.put("message","查询角色菜单失败！");
        }
        return map;
    }

    @RequestMapping("/list")
    public Map<String,Object> list(SysMenu sysMenu){
        List<SysMenu> list = iSysMenuService.list(sysMenu);
        Map<String,Object> map = new HashMap<>();
        if(list.size() > 0){
            map.put("code",0);
            map.put("result",list);
            map.put("message","查询角色菜单成功！");
        }else{
            map.put("code",-1);
            map.put("message","查询角色菜单失败！");
        }
        return map;
    }


    @RequestMapping("/addMenuToRole")
    public Map<String,Object> addMenuToRole(SysMenu sysMenu){
        System.out.println("前端传过来的菜单参数是"+sysMenu);
        Map<String,Object> map = new HashMap<>();
        if(0 != sysMenu.getParentId()){//判断该菜单是父菜单还是子菜单，如果是子菜单那么就走一下流程
            SysMenu s = new SysMenu();
            s.setMenuId(sysMenu.getParentId());
            s.setRoleId(sysMenu.getRoleId());
            Long has = iSysMenuService.SelectHas(s);
            if(null ==  has){//如果角色菜单表中没有该子菜单的父菜单存在那么在分配子菜单的时候就自动将他的父菜单加到角色菜单表中
                SysMenu sysMenu1 = iSysMenuService.selectByPrimaryKey(sysMenu.getParentId());
                sysMenu1.setRoleId(sysMenu.getRoleId());
                int n1 = iSysMenuService.addMenuToRole(sysMenu1);//添加该子菜单的父菜单到角色菜单表中
                int n = iSysMenuService.addMenuToRole(sysMenu);//添加该子菜单到角色菜单表中
                if(n > 0 && n1 > 0){
                    map.put("code",0);
                    map.put("message","分配角色菜单成功！");
                }else{
                    map.put("code",-1);
                    map.put("message","分配角色菜单失败！");
                }
            }else{//如果该子菜单的父菜单存在那么久直接添加到角色菜单表中
                int n = iSysMenuService.addMenuToRole(sysMenu);
                if(n > 0){
                    map.put("code",0);
                    map.put("message","分配角色菜单成功！");
                }else{
                    map.put("code",-1);
                    map.put("message","分配角色菜单失败！");
                }
            }
        }else{//如果是父菜单那么就直接添加
            int n = iSysMenuService.addMenuToRole(sysMenu);
            if(n > 0){
                map.put("code",0);
                map.put("message","分配角色菜单成功！");
            }else{
                map.put("code",-1);
                map.put("message","分配角色菜单失败！");
            }
        }

        return map;
    }

    @RequestMapping("/removeMenuToRole")
    public Map<String,Object> removeMenuToRole(SysMenu sysMenu){
        int n = iSysMenuService.removeMenuToRole(sysMenu);
        Map<String,Object> map = new HashMap<>();
        if(n > 0){
            map.put("code",0);
            map.put("message","撤销角色菜单成功！");
        }else{
            map.put("code",-1);
            map.put("message","撤销角色菜单失败！");
        }
        return map;
    }



}
